/**
 * 将自身各个属性为reducer的对象转换为一个reducer函数。
 * 当它被调用时，同时也会调用它的子reducer，并将它们的结果分别收集起来，放入对应属性下。
 * 这个属性名是它们被传入时所使用的属性名。
 * 比如：
 * combineReducers({
 *  moduleA: reducerA,
 *  moduleB: reducerB,
 * })
 * 执行后，这部分的state树：
 * {
 *  moduleA: reducerA(state.moduleA, action),
 *  moduleB: reducerB(state.moduleB, action),
 * }
 * state为当前这个combine后的reducer传入的state，可能是上层state树的一部分（对应属性下的内容）
 *
 * @param reducers
 * @return {function(*=, *=): *}
 */
export default function combineReducers(reducers) {
  const reducerKeys = Object.keys(reducers)
  const finalReducers = {}
  /**
   * 遍历传入对象的所有属性
   * 检查各个属性是否为{string}: {Function}形式的键值对，提取出合法的键值对
   */
  for (let i = 0; i < reducerKeys.length; i++) {
    const key = reducerKeys[i]

    if (process.env.NODE_ENV !== 'production') {
      if (typeof reducers[key] === 'undefined') {
        warning(`No reducer provided for key "${key}"`)
      }
    }

    if (typeof reducers[key] === 'function') {
      finalReducers[key] = reducers[key]
    }
  }
  const finalReducerKeys = Object.keys(finalReducers)

  let unexpectedKeyCache
  if (process.env.NODE_ENV !== 'production') {
    unexpectedKeyCache = {}
  }

  // 断言检查
  let shapeAssertionError
  try {
    assertReducerShape(finalReducers)
  } catch (e) {
    shapeAssertionError = e
  }

  /**
   * 回传改造后的reducer
   */
  return function combination(state = {}, action) {
    /**
     * 类型检查
     */
    if (shapeAssertionError) {
      throw shapeAssertionError
    }
    if (process.env.NODE_ENV !== 'production') {
      const warningMessage = getUnexpectedStateShapeWarningMessage(
        state,
        finalReducers,
        action,
        unexpectedKeyCache
      )
      if (warningMessage) {
        warning(warningMessage)
      }
    }

    let hasChanged = false
    const nextState = {}
    /**
     * 对自身的子reducer遍历传参执行
     */
    for (let i = 0; i < finalReducerKeys.length; i++) {
      const key = finalReducerKeys[i]
      /**
       * 取出对应reducer
       */
      const reducer = finalReducers[key]
      /**
       * 记录当前reducer执行前的，自身管理的state
       */
      const previousStateForKey = state[key]
      /**
       * 获得当前reducer执行后的，自身管理的state
       * 如果得到了undefined，要提示错误
       */
      const nextStateForKey = reducer(previousStateForKey, action)
      if (typeof nextStateForKey === 'undefined') {
        const errorMessage = getUndefinedStateErrorMessage(key, action)
        throw new Error(errorMessage)
      }

      /**
       * 没有错误的情况下，就加入父级的nextState
       */
      nextState[key] = nextStateForKey
      /**
       * 检查有没有发生改变，一旦有一处改变，即认定父state树发生了改变
       */
      hasChanged = hasChanged || nextStateForKey !== previousStateForKey
    }
    /**
     * 如果没有发生改变，就不需要返回一个新的对象
     */
    return hasChanged ? nextState : state
  }
}

/**
 * 一个典型的Middleware的形式
 * store其实是改造过的middlewareAPI
 * next表示内部一层的middleware，用来移交控制权。最内层的是dispatch
 * action在运行时被传入，传递真正的action
 */
export const crashReporter = store => next => action => {
  try {
    return next(action)
  } catch (err) {
    if (process.env.NODE_ENV !== 'production') {
      console.log('Caught an exception in Redux', err)
    }
  }
}

/**
 * 创建一个enhancer，将middleware的应用于dispatch方法。
 * 由于middleware可能是异步的，所以这个方法应当在最前面使用。
 * 每个dispatch都能在第一个传入的参数（middlewareAPI）中访问dispatch和getState
 * @param middlewares
 * @return {function(*): function(...[*]): {dispatch: dispatch}}
 */
export default function applyMiddleware(...middlewares) {
  // 先传入createStore，后面再传入reducer和preloadedState
  return createStore => (...args) => {
    // 创建store
    const store = createStore(...args)

    // 不允许在构建middleware时调用dispatch
    let dispatch = () => {
      throw new Error(
        `Dispatching while constructing your middleware is not allowed. ` +
        `Other middleware would not be applied to this dispatch.`
      )
    }

    /**
     * 构建middlewareAPI，替代store
     */
    const middlewareAPI = {
      getState: store.getState,
      dispatch: (...args) => dispatch(...args)
    }
    /**
     *  给每个middleware传入第一个参数store（使用middlewareAPI，而不是暴露整个store实例）
     */
    const chain = middlewares.map(middleware => middleware(middlewareAPI))

    /**
     * 将传入store的middleware互相嵌套起来，并传入第二个参数next
     * 最内层传入dispatch，从最内层开始运行，一级一级向外返回闭包，成为外层的第二个参数next
     */
    dispatch = compose(...chain)(store.dispatch)

    /**
     * 等到进行真正的dispatch的时候，传入第三个参数action
     */
    return {
      ...store,
      dispatch
    }
  }
}